package com.cancer.common.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 枚举转换工具
 *
 * @author 刘俊
 * @time 2015年6月15日
 */
public final class EnumUtil {
	/**
	 * 返回枚举常量的序数
	 * 
	 * @param clz
	 * @return
	 */
	public static List<Integer> enum2Ordinal(Class<? extends Enum<?>> clz) {
		// 判断传进来的类是否为Enum类型
		if (!clz.isEnum())
			return null;

		// 获取Enum中的每个取值
		Enum<?>[] enums = clz.getEnumConstants();
		List<Integer> ordinal = new ArrayList<Integer>();
		for (Enum<?> e : enums) {
			// 取得它的ordinal
			ordinal.add(e.ordinal());
		}

		return ordinal;
	}

	/**
	 * 返回此枚举常量的名称
	 * 
	 * @param clz
	 * @return
	 */
	public static List<String> enum2Name(Class<? extends Enum<?>> clz) {
		// 判断传进来的类是否为Enum类型
		if (!clz.isEnum())
			return null;

		// 获取Enum中的每个取值
		Enum<?>[] enums = clz.getEnumConstants();
		List<String> names = new ArrayList<String>();
		for (Enum<?> e : enums) {
			// 取得它的ordinal
			names.add(e.name());
		}

		return names;
	}
	
	/**
	 * 把枚举中的属性转成map
	 * 
	 * @author 刘俊 2015年6月15日
	 * @param clz 枚举类型
	 * @return
	 */
	public static List<Map<String, Object>> enum2List(Class<? extends Enum<?>> clz) {
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		// 判断传进来的类是否为Enum类型
		if (!clz.isEnum())
			return null;

		// 获取Enum中的每个取值
		Field[] fields = clz.getDeclaredFields();
		
		Enum<?>[] enums = clz.getEnumConstants();
		if (fields != null) {
			for (Enum<?> e : enums) {
				Map<String, Object> map = new HashMap<String, Object>();
				for (Field f : fields) {
					try { map.put(f.getName(), ReflectUtil.getProperty(e, f.getName())); } catch (Exception e1) {} 
				}
				list.add(map);
			}
		}
		
		return list;
	}


	/**
	 * 返回此枚举常量键值对
	 * 
	 * @param clz
	 * @return
	 */
	public static Map<Integer, String> enum2Map(Class<? extends Enum<?>> clz) {
		// 判断传进来的类是否为Enum类型
		if (!clz.isEnum())
			return null;

		// 获取Enum中的每个取值
		Enum<?>[] enums = clz.getEnumConstants();
		Map<Integer, String> map = new HashMap<Integer, String>();
		for (Enum<?> e : enums) {
			// 取得它的ordinal
			map.put(e.ordinal(), e.name());
		}

		return map;
	}

	/**
	 * 将枚举中的值的某个属性转换为字符串列表
	 * 
	 * @param clz
	 * @param propName某个属性值
	 * @return
	 */
	public static List<String> enumProp2List(Class<? extends Enum<?>> clz, String propName) {
		if (!clz.isEnum())
			return null;
		try {
			Enum<?>[] enums = clz.getEnumConstants();
			List<String> rels = new ArrayList<String>();
			for (Enum<?> en : enums) {
				rels.add((String) ReflectUtil.getProperty(en, propName));
			}
			return rels;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}

	/**
	 * 将枚举中的值的某个属性转换为序号和字符串列表
	 * 
	 * @param clz
	 * @param propName某个属性值
	 * @return
	 */
	public static Map<Integer, String> enumProp2OrdinalMap(Class<? extends Enum<?>> clz, String propName) {
		if (!clz.isEnum())
			return null;
		try {
			Enum<?>[] enums = clz.getEnumConstants();
			Map<Integer, String> rels = new HashMap<Integer, String>();
			for (Enum<?> en : enums) {
				rels.put(en.ordinal(), (String) ReflectUtil.getProperty(en, propName));
			}
			return rels;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}

	/**
	 * 将枚举中的值的某个属性转换为名称和字符串map
	 * 
	 * @param clz
	 * @param propName某个属性值
	 * @return
	 */
	public static Map<String, String> enumProp2NameMap(Class<? extends Enum<?>> clz, String propName) {
		if (!clz.isEnum())
			return null;
		try {
			Enum<?>[] enums = clz.getEnumConstants();
			Map<String, String> rels = new HashMap<String, String>();
			for (Enum<?> en : enums) {
				rels.put(en.name(), (String) ReflectUtil.getProperty(en, propName));
			}
			
			return rels;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}

	/**
	 * 将枚举中的两个属性转换为map
	 * 
	 * @param clz
	 * @param keyProp
	 *            要转化的key的属性名称
	 * @param valueProp
	 *            要转换的value的属性名称
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <K, V> Map<K, V> enumProp2Map(Class<? extends Enum<?>> clz, String keyProp, String valueProp) {
		if (!clz.isEnum())
			return null;
		try {
			Enum<?>[] enums = clz.getEnumConstants();
			Map<K, V> rels = new HashMap<K, V>();
			for (Enum<?> en : enums) {
				rels.put((K) ReflectUtil.getProperty(en, keyProp), (V) ReflectUtil.getProperty(en, valueProp));
			}
			return rels;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}
}
